using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("Network")]
	public class Network : MonoClass
	{
		public enum BnetLoginState
		{
			BATTLE_NET_UNKNOWN,
			BATTLE_NET_LOGGING_IN,
			BATTLE_NET_TIMEOUT,
			BATTLE_NET_LOGIN_FAILED,
			BATTLE_NET_LOGGED_IN
		}

		public enum BoosterSource
		{
			UNKNOWN = 0,
			ARENA_REWARD = 3,
			BOUGHT = 4,
			LICENSED = 6,
			CS_GIFT = 8,
			QUEST_REWARD = 10,
			BOUGHT_GOLD = 11
		}

		public enum Version
		{
			Patch = 0,
			Sku = 0,
			Minor = 4,
			Major = 9
		}

		[Attribute38("Network.ConnectErrorParams")]
		public class ConnectErrorParams : ErrorParams
		{
			public float m_creationTime => method_2<float>("m_creationTime");

			public ConnectErrorParams(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ConnectErrorParams(IntPtr address)
				: this(address, "ConnectErrorParams")
			{
			}
		}

		[Attribute38("Network.RequestContext")]
		public class RequestContext : MonoClass
		{
			public DateTime m_waitUntil => method_2<DateTime>("m_waitUntil");

			public int m_pendingResponseId => method_2<int>("m_pendingResponseId");

			public int m_requestId => method_2<int>("m_requestId");

			public int m_requestSubId => method_2<int>("m_requestSubId");

			public RequestContext(IntPtr address, string className)
				: base(address, className)
			{
			}

			public RequestContext(IntPtr address)
				: this(address, "RequestContext")
			{
			}
		}

		[Attribute38("Network.UnavailableReason")]
		public class UnavailableReason : MonoClass
		{
			public string mainReason => method_4("mainReason");

			public string subReason => method_4("subReason");

			public string extraData => method_4("extraData");

			public UnavailableReason(IntPtr address, string className)
				: base(address, className)
			{
			}

			public UnavailableReason(IntPtr address)
				: this(address, "UnavailableReason")
			{
			}
		}

		public enum AuthResult
		{
			UNKNOWN,
			ALLOWED,
			INVALID,
			SECOND,
			OFFLINE
		}

		[Attribute38("Network.QueueInfo")]
		public class QueueInfo : MonoClass
		{
			public int position => method_2<int>("position");

			public long secondsTilEnd => method_2<long>("secondsTilEnd");

			public long stdev => method_2<long>("stdev");

			public QueueInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public QueueInfo(IntPtr address)
				: this(address, "QueueInfo")
			{
			}
		}

		[Attribute38("Network.CanceledQuest")]
		public class CanceledQuest : MonoClass
		{
			public int AchieveID => method_11<int>("get_AchieveID", Array.Empty<object>());

			public bool Canceled => method_11<bool>("get_Canceled", Array.Empty<object>());

			public long NextQuestCancelDate => method_11<long>("get_NextQuestCancelDate", Array.Empty<object>());

			public CanceledQuest(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CanceledQuest(IntPtr address)
				: this(address, "CanceledQuest")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.TriggeredEvent")]
		public class TriggeredEvent : MonoClass
		{
			public int EventID => method_11<int>("get_EventID", Array.Empty<object>());

			public bool Success => method_11<bool>("get_Success", Array.Empty<object>());

			public TriggeredEvent(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TriggeredEvent(IntPtr address)
				: this(address, "TriggeredEvent")
			{
			}
		}

		[Attribute38("Network.AdventureProgress")]
		public class AdventureProgress : MonoClass
		{
			public int Wing => method_11<int>("get_Wing", Array.Empty<object>());

			public int Progress => method_11<int>("get_Progress", Array.Empty<object>());

			public int Ack => method_11<int>("get_Ack", Array.Empty<object>());

			public ulong Flags => method_11<ulong>("get_Flags", Array.Empty<object>());

			public AdventureProgress(IntPtr address, string className)
				: base(address, className)
			{
			}

			public AdventureProgress(IntPtr address)
				: this(address, "AdventureProgress")
			{
			}
		}

		[Attribute38("Network.CardSaleResult")]
		public class CardSaleResult : MonoClass
		{
			public enum SaleResult
			{
				GENERIC_FAILURE = 1,
				CARD_WAS_SOLD,
				CARD_WAS_BOUGHT,
				SOULBOUND,
				FAILED_WRONG_SELL_PRICE,
				FAILED_WRONG_BUY_PRICE,
				FAILED_NO_PERMISSION,
				FAILED_EVENT_NOT_ACTIVE,
				COUNT_MISMATCH
			}

			public SaleResult Action => method_11<SaleResult>("get_Action", Array.Empty<object>());

			public int AssetID => method_11<int>("get_AssetID", Array.Empty<object>());

			public string AssetName => method_13("get_AssetName");

			public TAG_PREMIUM Premium => method_11<TAG_PREMIUM>("get_Premium", Array.Empty<object>());

			public int Amount => method_11<int>("get_Amount", Array.Empty<object>());

			public int Count => method_11<int>("get_Count", Array.Empty<object>());

			public bool Nerfed => method_11<bool>("get_Nerfed", Array.Empty<object>());

			public int UnitSellPrice => method_11<int>("get_UnitSellPrice", Array.Empty<object>());

			public int UnitBuyPrice => method_11<int>("get_UnitBuyPrice", Array.Empty<object>());

			public CardSaleResult(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardSaleResult(IntPtr address)
				: this(address, "CardSaleResult")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.BeginDraft")]
		public class BeginDraft : MonoClass
		{
			public long DeckID => method_11<long>("get_DeckID", Array.Empty<object>());

			public List<NetCache.CardDefinition> Heroes => method_14<Class271<NetCache.CardDefinition>>("get_Heroes", Array.Empty<object>())?.method_25();

			public int Wins => method_11<int>("get_Wins", Array.Empty<object>());

			public int MaxSlot => method_11<int>("get_MaxSlot", Array.Empty<object>());

			public BeginDraft(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BeginDraft(IntPtr address)
				: this(address, "BeginDraft")
			{
			}
		}

		[Attribute38("Network.DraftChoicesAndContents")]
		public class DraftChoicesAndContents : MonoClass
		{
			public int Slot => method_11<int>("get_Slot", Array.Empty<object>());

			public List<NetCache.CardDefinition> Choices => method_14<Class271<NetCache.CardDefinition>>("get_Choices", Array.Empty<object>())?.method_25();

			public NetCache.CardDefinition Hero => method_14<NetCache.CardDefinition>("get_Hero", Array.Empty<object>());

			public NetCache.CardDefinition HeroPower => method_14<NetCache.CardDefinition>("get_HeroPower", Array.Empty<object>());

			public DeckContents DeckInfo => method_14<DeckContents>("get_DeckInfo", Array.Empty<object>());

			public int Wins => method_11<int>("get_Wins", Array.Empty<object>());

			public int Losses => method_11<int>("get_Losses", Array.Empty<object>());

			public int MaxWins => method_11<int>("get_MaxWins", Array.Empty<object>());

			public int MaxSlot => method_11<int>("get_MaxSlot", Array.Empty<object>());

			public DraftChoicesAndContents(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DraftChoicesAndContents(IntPtr address)
				: this(address, "DraftChoicesAndContents")
			{
			}
		}

		[Attribute38("Network.DraftChosen")]
		public class DraftChosen : MonoClass
		{
			public NetCache.CardDefinition ChosenCard => method_14<NetCache.CardDefinition>("get_ChosenCard", Array.Empty<object>());

			public List<NetCache.CardDefinition> NextChoices => method_14<Class271<NetCache.CardDefinition>>("get_NextChoices", Array.Empty<object>())?.method_25();

			public DraftChosen(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DraftChosen(IntPtr address)
				: this(address, "DraftChosen")
			{
			}
		}

		[Attribute38("Network.DraftRetired")]
		public class DraftRetired : MonoClass
		{
			public long Deck => method_11<long>("get_Deck", Array.Empty<object>());

			public DraftRetired(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DraftRetired(IntPtr address)
				: this(address, "DraftRetired")
			{
			}
		}

		[Attribute38("Network.MassDisenchantResponse")]
		public class MassDisenchantResponse : MonoClass
		{
			public int Amount => method_11<int>("get_Amount", Array.Empty<object>());

			public MassDisenchantResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public MassDisenchantResponse(IntPtr address)
				: this(address, "MassDisenchantResponse")
			{
			}
		}

		[Attribute38("Network.SetFavoriteHeroResponse")]
		public class SetFavoriteHeroResponse : MonoClass
		{
			public bool Success => method_2<bool>("Success");

			public TAG_CLASS HeroClass => method_2<TAG_CLASS>("HeroClass");

			public NetCache.CardDefinition Hero => method_3<NetCache.CardDefinition>("Hero");

			public SetFavoriteHeroResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public SetFavoriteHeroResponse(IntPtr address)
				: this(address, "SetFavoriteHeroResponse")
			{
			}
		}

		[Attribute38("Network.PurchaseErrorInfo")]
		public class PurchaseErrorInfo : MonoClass
		{
			public enum ErrorType
			{
				UNKNOWN = -1,
				SUCCESS = 0,
				STILL_IN_PROGRESS = 1,
				INVALID_BNET = 2,
				SERVICE_NA = 3,
				PURCHASE_IN_PROGRESS = 4,
				DATABASE = 5,
				INVALID_QUANTITY = 6,
				DUPLICATE_LICENSE = 7,
				REQUEST_NOT_SENT = 8,
				NO_ACTIVE_BPAY = 9,
				FAILED_RISK = 10,
				CANCELED = 11,
				WAIT_MOP = 12,
				WAIT_CONFIRM = 13,
				WAIT_RISK = 14,
				PRODUCT_NA = 0xF,
				RISK_TIMEOUT = 0x10,
				PRODUCT_ALREADY_OWNED = 17,
				WAIT_THIRD_PARTY_RECEIPT = 18,
				PRODUCT_EVENT_HAS_ENDED = 19,
				BP_GENERIC_FAIL = 100,
				BP_INVALID_CC_EXPIRY = 101,
				BP_RISK_ERROR = 102,
				BP_NO_VALID_PAYMENT = 103,
				BP_PAYMENT_AUTH = 104,
				BP_PROVIDER_DENIED = 105,
				BP_PURCHASE_BAN = 106,
				BP_SPENDING_LIMIT = 107,
				BP_PARENTAL_CONTROL = 108,
				BP_THROTTLED = 109,
				BP_THIRD_PARTY_BAD_RECEIPT = 110,
				BP_THIRD_PARTY_RECEIPT_USED = 111,
				BP_PRODUCT_UNIQUENESS_VIOLATED = 112,
				BP_REGION_IS_DOWN = 113,
				E_BP_GENERIC_FAIL_RETRY_CONTACT_CS_IF_PERSISTS = 115,
				E_BP_CHALLENGE_ID_FAILED_VERIFICATION = 116
			}

			public ErrorType Error => method_11<ErrorType>("get_Error", Array.Empty<object>());

			public string PurchaseInProgressProductID => method_13("get_PurchaseInProgressProductID");

			public string ErrorCode => method_13("get_ErrorCode");

			public PurchaseErrorInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PurchaseErrorInfo(IntPtr address)
				: this(address, "PurchaseErrorInfo")
			{
			}
		}

		[Attribute38("Network.PurchaseCanceledResponse")]
		public class PurchaseCanceledResponse : MonoClass
		{
			public enum CancelResult
			{
				SUCCESS,
				NOT_ALLOWED,
				NOTHING_TO_CANCEL
			}

			public CancelResult Result => method_11<CancelResult>("get_Result", Array.Empty<object>());

			public long TransactionID => method_11<long>("get_TransactionID", Array.Empty<object>());

			public string ProductID => method_13("get_ProductID");

			public string CurrencyCode => method_13("get_CurrencyCode");

			public PurchaseCanceledResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PurchaseCanceledResponse(IntPtr address)
				: this(address, "PurchaseCanceledResponse")
			{
			}
		}

		[Attribute38("Network.BattlePayStatus")]
		public class BattlePayStatus : MonoClass
		{
			public enum PurchaseState
			{
				UNKNOWN = -1,
				READY,
				CHECK_RESULTS,
				ERROR
			}

			public PurchaseState State => method_11<PurchaseState>("get_State", Array.Empty<object>());

			public long TransactionID => method_11<long>("get_TransactionID", Array.Empty<object>());

			public string ThirdPartyID => method_13("get_ThirdPartyID");

			public string ProductID => method_13("get_ProductID");

			public PurchaseErrorInfo PurchaseError => method_14<PurchaseErrorInfo>("get_PurchaseError", Array.Empty<object>());

			public bool BattlePayAvailable => method_11<bool>("get_BattlePayAvailable", Array.Empty<object>());

			public string CurrencyCode => method_13("get_CurrencyCode");

			public BattlePayStatus(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BattlePayStatus(IntPtr address)
				: this(address, "BattlePayStatus")
			{
			}
		}

		[Attribute38("Network.BundleItem")]
		public class BundleItem : MonoClass
		{
			public int ProductData => method_11<int>("get_ProductData", Array.Empty<object>());

			public int Quantity => method_11<int>("get_Quantity", Array.Empty<object>());

			public BundleItem(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BundleItem(IntPtr address)
				: this(address, "BundleItem")
			{
			}

			public new bool Equals(object obj)
			{
				return method_11<bool>("Equals", new object[1] { obj });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		[Attribute38("Network.Bundle")]
		public class Bundle : MonoClass
		{
			public string ProductID => method_13("get_ProductID");

			public string AppleID => method_13("get_AppleID");

			public string GooglePlayID => method_13("get_GooglePlayID");

			public string AmazonID => method_13("get_AmazonID");

			public List<BundleItem> Items => method_14<Class271<BundleItem>>("get_Items", Array.Empty<object>())?.method_25();

			public SpecialEventType ProductEvent => method_11<SpecialEventType>("get_ProductEvent", Array.Empty<object>());

			public SpecialEventType RealMoneyProductEvent => method_11<SpecialEventType>("get_RealMoneyProductEvent", Array.Empty<object>());

			public Bundle(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Bundle(IntPtr address)
				: this(address, "Bundle")
			{
			}
		}

		[Attribute38("Network.GoldCostBooster")]
		public class GoldCostBooster : MonoClass
		{
			public int ID => method_11<int>("get_ID", Array.Empty<object>());

			public SpecialEventType BuyWithGoldEvent => method_11<SpecialEventType>("get_BuyWithGoldEvent", Array.Empty<object>());

			public GoldCostBooster(IntPtr address, string className)
				: base(address, className)
			{
			}

			public GoldCostBooster(IntPtr address)
				: this(address, "GoldCostBooster")
			{
			}
		}

		[Attribute38("Network.BattlePayConfig")]
		public class BattlePayConfig : MonoClass
		{
			public bool Available => method_11<bool>("get_Available", Array.Empty<object>());

			public Currency Currency => method_14<Currency>("get_Currency", Array.Empty<object>());

			public List<Currency> Currencies => method_14<Class271<Currency>>("get_Currencies", Array.Empty<object>())?.method_25();

			public List<Bundle> Bundles => method_14<Class271<Bundle>>("get_Bundles", Array.Empty<object>())?.method_25();

			public List<GoldCostBooster> GoldCostBoosters => method_14<Class271<GoldCostBooster>>("get_GoldCostBoosters", Array.Empty<object>())?.method_25();

			public int SecondsBeforeAutoCancel => method_11<int>("get_SecondsBeforeAutoCancel", Array.Empty<object>());

			public BattlePayConfig(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BattlePayConfig(IntPtr address)
				: this(address, "BattlePayConfig")
			{
			}
		}

		[Attribute38("Network.PurchaseViaGoldResponse")]
		public class PurchaseViaGoldResponse : MonoClass
		{
			public enum ErrorType
			{
				UNKNOWN = -1,
				SUCCESS = 1,
				INSUFFICIENT_GOLD = 2,
				PRODUCT_NA = 3,
				FEATURE_NA = 4,
				INVALID_QUANTITY = 5
			}

			public ErrorType Error => method_11<ErrorType>("get_Error", Array.Empty<object>());

			public long GoldUsed => method_11<long>("get_GoldUsed", Array.Empty<object>());

			public PurchaseViaGoldResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PurchaseViaGoldResponse(IntPtr address)
				: this(address, "PurchaseViaGoldResponse")
			{
			}
		}

		[Attribute38("Network.PurchaseMethod")]
		public class PurchaseMethod : MonoClass
		{
			public long TransactionID => method_11<long>("get_TransactionID", Array.Empty<object>());

			public string ProductID => method_13("get_ProductID");

			public int Quantity => method_11<int>("get_Quantity", Array.Empty<object>());

			public string CurrencyCode => method_13("get_CurrencyCode");

			public string WalletName => method_13("get_WalletName");

			public bool UseEBalance => method_11<bool>("get_UseEBalance", Array.Empty<object>());

			public bool IsZeroCostLicense => method_11<bool>("get_IsZeroCostLicense", Array.Empty<object>());

			public string ChallengeID => method_13("get_ChallengeID");

			public string ChallengeURL => method_13("get_ChallengeURL");

			public PurchaseErrorInfo PurchaseError => method_14<PurchaseErrorInfo>("get_PurchaseError", Array.Empty<object>());

			public PurchaseMethod(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PurchaseMethod(IntPtr address)
				: this(address, "PurchaseMethod")
			{
			}
		}

		[Attribute38("Network.PurchaseResponse")]
		public class PurchaseResponse : MonoClass
		{
			public PurchaseErrorInfo PurchaseError => method_14<PurchaseErrorInfo>("get_PurchaseError", Array.Empty<object>());

			public long TransactionID => method_11<long>("get_TransactionID", Array.Empty<object>());

			public string ProductID => method_13("get_ProductID");

			public string ThirdPartyID => method_13("get_ThirdPartyID");

			public string CurrencyCode => method_13("get_CurrencyCode");

			public PurchaseResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PurchaseResponse(IntPtr address)
				: this(address, "PurchaseResponse")
			{
			}
		}

		[Attribute38("Network.ThirdPartyPurchaseStatusResponse")]
		public class ThirdPartyPurchaseStatusResponse : MonoClass
		{
			public enum PurchaseStatus
			{
				UNKNOWN = -1,
				NOT_FOUND = 1,
				SUCCEEDED = 2,
				FAILED = 3,
				IN_PROGRESS = 4
			}

			public string ThirdPartyID => method_13("get_ThirdPartyID");

			public PurchaseStatus Status => method_11<PurchaseStatus>("get_Status", Array.Empty<object>());

			public ThirdPartyPurchaseStatusResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ThirdPartyPurchaseStatusResponse(IntPtr address)
				: this(address, "ThirdPartyPurchaseStatusResponse")
			{
			}
		}

		[Attribute38("Network.CardBackResponse")]
		public class CardBackResponse : MonoClass
		{
			public bool Success => method_11<bool>("get_Success", Array.Empty<object>());

			public int CardBack => method_11<int>("get_CardBack", Array.Empty<object>());

			public CardBackResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardBackResponse(IntPtr address)
				: this(address, "CardBackResponse")
			{
			}
		}

		[Attribute38("Network.GameCancelInfo")]
		public class GameCancelInfo : MonoClass
		{
			public enum Reason
			{
				OPPONENT_TIMEOUT = 1,
				PLAYER_LOADING_TIMEOUT,
				PLAYER_LOADING_DISCONNECTED
			}

			public Reason CancelReason => method_11<Reason>("get_CancelReason", Array.Empty<object>());

			public GameCancelInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public GameCancelInfo(IntPtr address)
				: this(address, "GameCancelInfo")
			{
			}
		}

		[Attribute38("Network.Entity")]
		public class Entity : MonoClass
		{
			[Attribute38("Network.Entity.Tag")]
			public class Tag : MonoClass
			{
				public int Name => method_11<int>("get_Name", Array.Empty<object>());

				public int Value => method_11<int>("get_Value", Array.Empty<object>());

				public Tag(IntPtr address, string className)
					: base(address, className)
				{
				}

				public Tag(IntPtr address)
					: this(address, "Tag")
				{
				}
			}

			public int ID => method_11<int>("get_ID", Array.Empty<object>());

			public List<Tag> Tags => method_14<Class271<Tag>>("get_Tags", Array.Empty<object>())?.method_25();

			public List<Tag> DefTags => method_14<Class271<Tag>>("get_DefTags", Array.Empty<object>())?.method_25();

			public string CardID => method_13("get_CardID");

			public Entity(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Entity(IntPtr address)
				: this(address, "Entity")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.Options")]
		public class Options : MonoClass
		{
			[Attribute38("Network.Options.Option")]
			public class Option : MonoClass
			{
				public enum OptionType
				{
					PASS = 1,
					END_TURN,
					POWER
				}

				[Attribute38("Network.Options.Option.PlayErrorInfo")]
				public class PlayErrorInfo : MonoClass
				{
					public PlayErrors.ErrorType PlayError => method_11<PlayErrors.ErrorType>("get_PlayError", Array.Empty<object>());

					public PlayErrorInfo(IntPtr address, string className)
						: base(address, className)
					{
					}

					public PlayErrorInfo(IntPtr address)
						: this(address, "PlayErrorInfo")
					{
					}

					public bool IsValid()
					{
						return method_11<bool>("IsValid", Array.Empty<object>());
					}
				}

				[Attribute38("Network.Options.Option.TargetOption")]
				public class TargetOption : MonoClass
				{
					public int ID => method_11<int>("get_ID", Array.Empty<object>());

					public PlayErrorInfo PlayErrorInfo => method_14<PlayErrorInfo>("get_PlayErrorInfo", Array.Empty<object>());

					public TargetOption(IntPtr address, string className)
						: base(address, className)
					{
					}

					public TargetOption(IntPtr address)
						: this(address, "TargetOption")
					{
					}

					public void CopyFrom(TargetOption targetOption)
					{
						method_9("CopyFrom", new Class276.Enum20[1] { Class276.Enum20.Class }, targetOption);
					}
				}

				[Attribute38("Network.Options.Option.SubOption")]
				public class SubOption : MonoClass
				{
					public int ID => method_11<int>("get_ID", Array.Empty<object>());

					public List<TargetOption> Targets => method_14<Class271<TargetOption>>("get_Targets", Array.Empty<object>())?.method_25();

					public PlayErrorInfo PlayErrorInfo => method_14<PlayErrorInfo>("get_PlayErrorInfo", Array.Empty<object>());

					public SubOption(IntPtr address, string className)
						: base(address, className)
					{
					}

					public SubOption(IntPtr address)
						: this(address, "SubOption")
					{
					}

					public bool IsValidTarget(int entityID)
					{
						return method_11<bool>("IsValidTarget", new object[1] { entityID });
					}

					public PlayErrors.ErrorType GetErrorForTarget(int entityID)
					{
						return method_11<PlayErrors.ErrorType>("GetErrorForTarget", new object[1] { entityID });
					}

					public bool HasValidTarget()
					{
						return method_11<bool>("HasValidTarget", Array.Empty<object>());
					}

					public void CopyFrom(SubOption subOption)
					{
						method_8("CopyFrom", subOption);
					}
				}

				public OptionType Type => method_11<OptionType>("get_Type", Array.Empty<object>());

				public SubOption Main => method_14<SubOption>("get_Main", Array.Empty<object>());

				public List<SubOption> Subs => method_14<Class271<SubOption>>("get_Subs", Array.Empty<object>())?.method_25();

				public Option(IntPtr address, string className)
					: base(address, className)
				{
				}

				public Option(IntPtr address)
					: this(address, "Option")
				{
				}

				public SubOption GetSubOptionFromEntityID(int entityID)
				{
					return method_14<SubOption>("GetSubOptionFromEntityID", new object[1] { entityID });
				}

				public bool HasValidSubOption()
				{
					return method_11<bool>("HasValidSubOption", Array.Empty<object>());
				}

				public void CopyFrom(Option option)
				{
					method_8("CopyFrom", option);
				}
			}

			public int ID => method_11<int>("get_ID", Array.Empty<object>());

			public List<Option> List => method_14<Class271<Option>>("get_List", Array.Empty<object>())?.method_25();

			public Options(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Options(IntPtr address)
				: this(address, "Options")
			{
			}

			public bool HasValidOption()
			{
				return method_11<bool>("HasValidOption", Array.Empty<object>());
			}

			public Option GetOptionFromEntityID(int entityID)
			{
				return method_14<Option>("GetOptionFromEntityID", new object[1] { entityID });
			}

			public void CopyFrom(Options options)
			{
				method_8("CopyFrom", options);
			}
		}

		[Attribute38("Network.EntityChoices")]
		public class EntityChoices : MonoClass
		{
			public int ID => method_11<int>("get_ID", Array.Empty<object>());

			public CHOICE_TYPE ChoiceType => method_11<CHOICE_TYPE>("get_ChoiceType", Array.Empty<object>());

			public int CountMin => method_11<int>("get_CountMin", Array.Empty<object>());

			public int CountMax => method_11<int>("get_CountMax", Array.Empty<object>());

			public List<int> Entities => method_14<Class270<int>>("get_Entities", Array.Empty<object>())?.method_25();

			public int Source => method_11<int>("get_Source", Array.Empty<object>());

			public int PlayerId => method_11<int>("get_PlayerId", Array.Empty<object>());

			public bool HideChosen => method_11<bool>("get_HideChosen", Array.Empty<object>());

			public EntityChoices(IntPtr address, string className)
				: base(address, className)
			{
			}

			public EntityChoices(IntPtr address)
				: this(address, "EntityChoices")
			{
			}
		}

		[Attribute38("Network.EntitiesChosen")]
		public class EntitiesChosen : MonoClass
		{
			public int ID => method_11<int>("get_ID", Array.Empty<object>());

			public List<int> Entities => method_14<Class270<int>>("get_Entities", Array.Empty<object>())?.method_25();

			public int PlayerId => method_11<int>("get_PlayerId", Array.Empty<object>());

			public CHOICE_TYPE ChoiceType => method_11<CHOICE_TYPE>("get_ChoiceType", Array.Empty<object>());

			public EntitiesChosen(IntPtr address, string className)
				: base(address, className)
			{
			}

			public EntitiesChosen(IntPtr address)
				: this(address, "EntitiesChosen")
			{
			}
		}

		[Attribute38("Network.Notification")]
		public class Notification : MonoClass
		{
			public enum Type
			{
				IN_HAND_CARD_CAP = 1,
				MANA_CAP
			}

			public Type NotificationType => method_11<Type>("get_NotificationType", Array.Empty<object>());

			public Notification(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Notification(IntPtr address)
				: this(address, "Notification")
			{
			}
		}

		[Attribute38("Network.GameSetup")]
		public class GameSetup : MonoClass
		{
			public int Board => method_11<int>("get_Board", Array.Empty<object>());

			public int MaxSecretZoneSizePerPlayer => method_11<int>("get_MaxSecretZoneSizePerPlayer", Array.Empty<object>());

			public int MaxSecretsPerPlayer => method_11<int>("get_MaxSecretsPerPlayer", Array.Empty<object>());

			public int MaxQuestsPerPlayer => method_11<int>("get_MaxQuestsPerPlayer", Array.Empty<object>());

			public int MaxFriendlyMinionsPerPlayer => method_11<int>("get_MaxFriendlyMinionsPerPlayer", Array.Empty<object>());

			public int DisconnectWhenStuckSeconds => method_11<int>("get_DisconnectWhenStuckSeconds", Array.Empty<object>());

			public GameSetup(IntPtr address, string className)
				: base(address, className)
			{
			}

			public GameSetup(IntPtr address)
				: this(address, "GameSetup")
			{
			}
		}

		[Attribute38("Network.UserUI")]
		public class UserUI : MonoClass
		{
			[Attribute38("Network.UserUI.MouseInfo")]
			public class MouseInfo : MonoClass
			{
				public int OverCardID => method_11<int>("get_OverCardID", Array.Empty<object>());

				public int HeldCardID => method_11<int>("get_HeldCardID", Array.Empty<object>());

				public int ArrowOriginID => method_11<int>("get_ArrowOriginID", Array.Empty<object>());

				public int X => method_11<int>("get_X", Array.Empty<object>());

				public int Y => method_11<int>("get_Y", Array.Empty<object>());

				public MouseInfo(IntPtr address, string className)
					: base(address, className)
				{
				}

				public MouseInfo(IntPtr address)
					: this(address, "MouseInfo")
				{
				}
			}

			[Attribute38("Network.UserUI.EmoteInfo")]
			public class EmoteInfo : MonoClass
			{
				public int Emote => method_11<int>("get_Emote", Array.Empty<object>());

				public EmoteInfo(IntPtr address, string className)
					: base(address, className)
				{
				}

				public EmoteInfo(IntPtr address)
					: this(address, "EmoteInfo")
				{
				}
			}

			public MouseInfo mouseInfo => method_3<MouseInfo>("mouseInfo");

			public EmoteInfo emoteInfo => method_3<EmoteInfo>("emoteInfo");

			public UserUI(IntPtr address, string className)
				: base(address, className)
			{
			}

			public UserUI(IntPtr address)
				: this(address, "UserUI")
			{
			}
		}

		public enum PowerType
		{
			FULL_ENTITY = 1,
			SHOW_ENTITY,
			HIDE_ENTITY,
			TAG_CHANGE,
			BLOCK_START,
			BLOCK_END,
			CREATE_GAME,
			META_DATA,
			CHANGE_ENTITY
		}

		[Attribute38("Network.PowerHistory")]
		public class PowerHistory : MonoClass
		{
			public PowerType Type => method_11<PowerType>("get_Type", Array.Empty<object>());

			public PowerHistory(IntPtr address, string className)
				: base(address, className)
			{
			}

			public PowerHistory(IntPtr address)
				: this(address, "PowerHistory")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistBlockStart")]
		public class HistBlockStart : PowerHistory
		{
			public int Entity => method_11<int>("get_Entity", Array.Empty<object>());

			public int Target => method_11<int>("get_Target", Array.Empty<object>());

			public int SubOption => method_11<int>("get_SubOption", Array.Empty<object>());

			public string EffectCardId => method_13("get_EffectCardId");

			public int EffectIndex => method_11<int>("get_EffectIndex", Array.Empty<object>());

			public int TriggerKeyword => method_11<int>("get_TriggerKeyword", Array.Empty<object>());

			public HistBlockStart(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistBlockStart(IntPtr address)
				: this(address, "HistBlockStart")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistBlockEnd")]
		public class HistBlockEnd : PowerHistory
		{
			public HistBlockEnd(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistBlockEnd(IntPtr address)
				: this(address, "HistBlockEnd")
			{
			}
		}

		[Attribute38("Network.HistCreateGame")]
		public class HistCreateGame : PowerHistory
		{
			[Attribute38("Network.HistCreateGame.PlayerData")]
			public class PlayerData : MonoClass
			{
				public int ID => method_11<int>("get_ID", Array.Empty<object>());

				public Entity Player => method_14<Entity>("get_Player", Array.Empty<object>());

				public int CardBackID => method_11<int>("get_CardBackID", Array.Empty<object>());

				public PlayerData(IntPtr address, string className)
					: base(address, className)
				{
				}

				public PlayerData(IntPtr address)
					: this(address, "PlayerData")
				{
				}

				public new string ToString()
				{
					return method_13("ToString");
				}
			}

			public Entity Game => method_14<Entity>("get_Game", Array.Empty<object>());

			public List<PlayerData> Players => method_14<Class271<PlayerData>>("get_Players", Array.Empty<object>())?.method_25();

			public HistCreateGame(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistCreateGame(IntPtr address)
				: this(address, "HistCreateGame")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistFullEntity")]
		public class HistFullEntity : PowerHistory
		{
			public Entity Entity => method_14<Entity>("get_Entity", Array.Empty<object>());

			public HistFullEntity(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistFullEntity(IntPtr address)
				: this(address, "HistFullEntity")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistShowEntity")]
		public class HistShowEntity : PowerHistory
		{
			public Entity Entity => method_14<Entity>("get_Entity", Array.Empty<object>());

			public HistShowEntity(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistShowEntity(IntPtr address)
				: this(address, "HistShowEntity")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistHideEntity")]
		public class HistHideEntity : PowerHistory
		{
			public int Entity => method_11<int>("get_Entity", Array.Empty<object>());

			public int Zone => method_11<int>("get_Zone", Array.Empty<object>());

			public HistHideEntity(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistHideEntity(IntPtr address)
				: this(address, "HistHideEntity")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistChangeEntity")]
		public class HistChangeEntity : PowerHistory
		{
			public Entity Entity => method_14<Entity>("get_Entity", Array.Empty<object>());

			public HistChangeEntity(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistChangeEntity(IntPtr address)
				: this(address, "HistChangeEntity")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistTagChange")]
		public class HistTagChange : PowerHistory
		{
			public int Entity => method_11<int>("get_Entity", Array.Empty<object>());

			public int Tag => method_11<int>("get_Tag", Array.Empty<object>());

			public int Value => method_11<int>("get_Value", Array.Empty<object>());

			public bool ChangeDef => method_11<bool>("get_ChangeDef", Array.Empty<object>());

			public HistTagChange(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistTagChange(IntPtr address)
				: this(address, "HistTagChange")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HistMetaData")]
		public class HistMetaData : PowerHistory
		{
			public List<int> Info => method_14<Class270<int>>("get_Info", Array.Empty<object>())?.method_25();

			public int Data => method_11<int>("get_Data", Array.Empty<object>());

			public HistMetaData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HistMetaData(IntPtr address)
				: this(address, "HistMetaData")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.CardUserData")]
		public class CardUserData : MonoClass
		{
			public int DbId => method_11<int>("get_DbId", Array.Empty<object>());

			public int Count => method_11<int>("get_Count", Array.Empty<object>());

			public TAG_PREMIUM Premium => method_11<TAG_PREMIUM>("get_Premium", Array.Empty<object>());

			public CardUserData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardUserData(IntPtr address)
				: this(address, "CardUserData")
			{
			}
		}

		[Attribute38("Network.DeckContents")]
		public class DeckContents : MonoClass
		{
			public long Deck => method_11<long>("get_Deck", Array.Empty<object>());

			public List<CardUserData> Cards => method_14<Class271<CardUserData>>("get_Cards", Array.Empty<object>())?.method_25();

			public DeckContents(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DeckContents(IntPtr address)
				: this(address, "DeckContents")
			{
			}
		}

		[Attribute38("Network.DeckName")]
		public class DeckName : MonoClass
		{
			public long Deck => method_11<long>("get_Deck", Array.Empty<object>());

			public string Name => method_13("get_Name");

			public DeckName(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DeckName(IntPtr address)
				: this(address, "DeckName")
			{
			}
		}

		[Attribute38("Network.DeckCard")]
		public class DeckCard : MonoClass
		{
			public long Deck => method_11<long>("get_Deck", Array.Empty<object>());

			public long Card => method_11<long>("get_Card", Array.Empty<object>());

			public DeckCard(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DeckCard(IntPtr address)
				: this(address, "DeckCard")
			{
			}
		}

		[Attribute38("Network.GenericResponse")]
		public class GenericResponse : MonoClass
		{
			public enum Result
			{
				OK = 0,
				REQUEST_IN_PROCESS = 1,
				REQUEST_COMPLETE = 2,
				FIRST_ERROR = 100,
				INTERNAL_ERROR = 101,
				DB_ERROR = 102,
				INVALID_REQUEST = 103,
				LOGIN_LOAD = 104,
				RESULT_DATA_MIGRATION_OR_PLAYER_ID_ERROR = 105
			}

			public int RequestId => method_11<int>("get_RequestId", Array.Empty<object>());

			public int RequestSubId => method_11<int>("get_RequestSubId", Array.Empty<object>());

			public Result ResultCode => method_11<Result>("get_ResultCode", Array.Empty<object>());

			public object GenericData => method_14<object>("get_GenericData", Array.Empty<object>());

			public GenericResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public GenericResponse(IntPtr address)
				: this(address, "GenericResponse")
			{
			}
		}

		[Attribute38("Network.DBAction")]
		public class DBAction : MonoClass
		{
			public enum ActionType
			{
				UNKNOWN,
				GET_DECK,
				CREATE_DECK,
				RENAME_DECK,
				DELETE_DECK,
				SET_DECK,
				OPEN_BOOSTER,
				GAMES_INFO
			}

			public enum ResultType
			{
				UNKNOWN,
				SUCCESS,
				NOT_OWNED,
				CONSTRAINT
			}

			public ActionType Action => method_11<ActionType>("get_Action", Array.Empty<object>());

			public ResultType Result => method_11<ResultType>("get_Result", Array.Empty<object>());

			public long MetaData => method_11<long>("get_MetaData", Array.Empty<object>());

			public DBAction(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DBAction(IntPtr address)
				: this(address, "DBAction")
			{
			}
		}

		[Attribute38("Network.TurnTimerInfo")]
		public class TurnTimerInfo : MonoClass
		{
			public float Seconds => method_11<float>("get_Seconds", Array.Empty<object>());

			public int Turn => method_11<int>("get_Turn", Array.Empty<object>());

			public bool Show => method_11<bool>("get_Show", Array.Empty<object>());

			public TurnTimerInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TurnTimerInfo(IntPtr address)
				: this(address, "TurnTimerInfo")
			{
			}
		}

		[Attribute38("Network.CardQuote")]
		public class CardQuote : MonoClass
		{
			public enum QuoteState
			{
				SUCCESS,
				UNKNOWN_ERROR
			}

			public int AssetID => method_11<int>("get_AssetID", Array.Empty<object>());

			public int BuyPrice => method_11<int>("get_BuyPrice", Array.Empty<object>());

			public int SaleValue => method_11<int>("get_SaleValue", Array.Empty<object>());

			public QuoteState Status => method_11<QuoteState>("get_Status", Array.Empty<object>());

			public CardQuote(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardQuote(IntPtr address)
				: this(address, "CardQuote")
			{
			}
		}

		[Attribute38("Network.GameEnd")]
		public class GameEnd : MonoClass
		{
			public List<NetCache.ProfileNotice> Notices => method_14<Class271<NetCache.ProfileNotice>>("get_Notices", Array.Empty<object>())?.method_25();

			public GameEnd(IntPtr address, string className)
				: base(address, className)
			{
			}

			public GameEnd(IntPtr address)
				: this(address, "GameEnd")
			{
			}
		}

		[Attribute38("Network.ProfileNotices")]
		public class ProfileNotices : MonoClass
		{
			public List<NetCache.ProfileNotice> Notices => method_14<Class271<NetCache.ProfileNotice>>("get_Notices", Array.Empty<object>())?.method_25();

			public ProfileNotices(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ProfileNotices(IntPtr address)
				: this(address, "ProfileNotices")
			{
			}
		}

		[Attribute38("Network.AccountLicenseAchieveResponse")]
		public class AccountLicenseAchieveResponse : MonoClass
		{
			public enum AchieveResult
			{
				INVALID_ACHIEVE = 1,
				NOT_ACTIVE,
				IN_PROGRESS,
				COMPLETE,
				STATUS_UNKNOWN
			}

			public int Achieve => method_11<int>("get_Achieve", Array.Empty<object>());

			public AchieveResult Result => method_11<AchieveResult>("get_Result", Array.Empty<object>());

			public AccountLicenseAchieveResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public AccountLicenseAchieveResponse(IntPtr address)
				: this(address, "AccountLicenseAchieveResponse")
			{
			}
		}

		[Attribute38("Network.DebugConsoleResponse")]
		public class DebugConsoleResponse : MonoClass
		{
			public int Type => method_11<int>("get_Type", Array.Empty<object>());

			public string Response => method_13("get_Response");

			public DebugConsoleResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DebugConsoleResponse(IntPtr address)
				: this(address, "DebugConsoleResponse")
			{
			}
		}

		[Attribute38("Network.RecruitInfo")]
		public class RecruitInfo : MonoClass
		{
			public ulong ID => method_11<ulong>("get_ID", Array.Empty<object>());

			public string Nickname => method_13("get_Nickname");

			public int Status => method_11<int>("get_Status", Array.Empty<object>());

			public int Level => method_11<int>("get_Level", Array.Empty<object>());

			public ulong CreationTimeMicrosec => method_11<ulong>("get_CreationTimeMicrosec", Array.Empty<object>());

			public RecruitInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public RecruitInfo(IntPtr address)
				: this(address, "RecruitInfo")
			{
			}

			public new string ToString()
			{
				return method_13("ToString");
			}
		}

		[Attribute38("Network.HSClientInterface")]
		public class HSClientInterface : MonoClass
		{
			public string s_tempCachePath => method_4("s_tempCachePath");

			public HSClientInterface(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HSClientInterface(IntPtr address)
				: this(address, "HSClientInterface")
			{
			}

			public string GetVersion()
			{
				return method_13("GetVersion");
			}

			public bool IsVersionInt()
			{
				return method_11<bool>("IsVersionInt", Array.Empty<object>());
			}

			public string GetUserAgent()
			{
				return method_13("GetUserAgent");
			}

			public int GetApplicationVersion()
			{
				return method_11<int>("GetApplicationVersion", Array.Empty<object>());
			}

			public string CleanUserAgentString(string data)
			{
				return method_13("CleanUserAgentString", data);
			}

			public string GetBasePersistentDataPath()
			{
				return method_13("GetBasePersistentDataPath");
			}

			public string GetTemporaryCachePath()
			{
				return method_13("GetTemporaryCachePath");
			}

			public bool GetDisableConnectionMetering()
			{
				return method_11<bool>("GetDisableConnectionMetering", Array.Empty<object>());
			}

			public string GetAuroraVersionName()
			{
				return method_13("GetAuroraVersionName");
			}

			public string GetLocaleName()
			{
				return method_13("GetLocaleName");
			}

			public string GetPlatformName()
			{
				return method_13("GetPlatformName");
			}
		}

		public static int NoSubOption => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "Network", "NoSubOption");

		public static int NoPosition => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "Network", "NoPosition");

		public static string TutorialServer => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "Network", "TutorialServer");

		public static string CosmeticVersion => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "Network", "CosmeticVersion");

		public static string VersionPostfix => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "Network", "VersionPostfix");

		public static string DEFAULT_INTERNAL_ENVIRONMENT => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "Network", "DEFAULT_INTERNAL_ENVIRONMENT");

		public static string DEFAULT_PUBLIC_ENVIRONMENT => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "Network", "DEFAULT_PUBLIC_ENVIRONMENT");

		public static TimeSpan LOGIN_TIMEOUT => MonoClass.smethod_6<TimeSpan>(TritonHs.MainAssemblyPath, "", "Network", "LOGIN_TIMEOUT");

		public static TimeSpan PROCESS_WARNING => MonoClass.smethod_6<TimeSpan>(TritonHs.MainAssemblyPath, "", "Network", "PROCESS_WARNING");

		public static TimeSpan PROCESS_WARNING_REPORT_GAP => MonoClass.smethod_6<TimeSpan>(TritonHs.MainAssemblyPath, "", "Network", "PROCESS_WARNING_REPORT_GAP");

		public static int MIN_DEFERRED_WAIT => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "Network", "MIN_DEFERRED_WAIT");

		public static TimeSpan MAX_DEFERRED_WAIT => MonoClass.smethod_6<TimeSpan>(TritonHs.MainAssemblyPath, "", "Network", "MAX_DEFERRED_WAIT");

		public static bool s_running => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "Network", "s_running");

		public static UnityUrlDownloader s_urlDownloader => MonoClass.smethod_7<UnityUrlDownloader>(TritonHs.MainAssemblyPath, "", "Network", "s_urlDownloader");

		public bool m_loginWaiting => method_2<bool>("m_loginWaiting");

		public DateTime m_loginStarted => method_2<DateTime>("m_loginStarted");

		public DateTime lastCall => method_2<DateTime>("lastCall");

		public DateTime lastCallReport => method_2<DateTime>("lastCallReport");

		public GameServerInfo m_lastGameServerInfo => method_14<GameServerInfo>("GetLastGameServerJoined", Array.Empty<object>());

		public string m_delayedError => method_4("m_delayedError");

		public float m_timeBeforeAllowReset => method_2<float>("m_timeBeforeAllowReset");

		public static int s_numConnectionFailures => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "Network", "s_numConnectionFailures");

		public static int SEND_DECK_DATA_NO_HERO_ASSET_CHANGE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "Network", "SEND_DECK_DATA_NO_HERO_ASSET_CHANGE");

		public static int SEND_DECK_DATA_NO_CARD_BACK_CHANGE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "Network", "SEND_DECK_DATA_NO_CARD_BACK_CHANGE");

		public static int s_gameServerKeepAliveFrequencySeconds => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "Network", "s_gameServerKeepAliveFrequencySeconds");

		public static bool s_gameConceded => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "Network", "s_gameConceded");

		public static bool s_disconnectRequested => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "Network", "s_disconnectRequested");

		public static bool ReconnectAfterFailedPings => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "Network", "ReconnectAfterFailedPings");

		public static List<ConnectErrorParams> s_errorList => MonoClass.smethod_7<Class271<ConnectErrorParams>>(TritonHs.MainAssemblyPath, "", "Network", "s_errorList")?.method_25();

		public static float ERROR_HANDLING_DELAY => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "Network", "ERROR_HANDLING_DELAY");

		public static List<RequestContext> m_inTransitRequests => MonoClass.smethod_7<Class271<RequestContext>>(TritonHs.MainAssemblyPath, "", "Network", "m_inTransitRequests")?.method_25();

		public static bool s_shouldBeConnectedToAurora => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "Network", "s_shouldBeConnectedToAurora");

		public Network(IntPtr address, string className)
			: base(address, className)
		{
		}

		public Network(IntPtr address)
			: this(address, "Network")
		{
		}

		public static int ProductVersion()
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "Network", "ProductVersion", Array.Empty<object>());
		}

		public static TimeSpan GetMaxDeferredWait()
		{
			return MonoClass.smethod_14<TimeSpan>(TritonHs.MainAssemblyPath, "", "Network", "GetMaxDeferredWait", Array.Empty<object>());
		}

		public static void ProcessRequestTimeouts()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "ProcessRequestTimeouts");
		}

		public static void AddPendingRequestTimeout(int requestId, int requestSubId)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AddPendingRequestTimeout", requestId, requestSubId);
		}

		public static void RemovePendingRequestTimeout(int pendingResponseId)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "RemovePendingRequestTimeout", pendingResponseId);
		}

		public static void OnRequestTimeout(int pendingResponseId, int requestId, int requestSubId)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "OnRequestTimeout", pendingResponseId, requestId, requestSubId);
		}

		public static void OnGenericResponse()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "OnGenericResponse");
		}

		public static bool IsRunning()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "IsRunning", Array.Empty<object>());
		}

		public static double TimeSinceLastPong()
		{
			return MonoClass.smethod_14<double>(TritonHs.MainAssemblyPath, "", "Network", "TimeSinceLastPong", Array.Empty<object>());
		}

		public static void OnSubscribeResponse()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "OnSubscribeResponse");
		}

		public static void OnClientStateNotification()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "OnClientStateNotification");
		}

		public static void Reset()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "Reset");
		}

		public static void ApplicationPaused()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "ApplicationPaused");
		}

		public static void CloseAll()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "CloseAll");
		}

		public static void ApplicationUnpaused()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "ApplicationUnpaused");
		}

		public static void Heartbeat()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "Heartbeat");
		}

		public static void ProcessConnectApiHeartbeat()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "ProcessConnectApiHeartbeat");
		}

		public static void AddErrorToList(ConnectErrorParams errorParams)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AddErrorToList", errorParams);
		}

		public static void UpdatePingPong()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "UpdatePingPong");
		}

		public static void GetBattleNetPackets()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "GetBattleNetPackets");
		}

		public static void AppQuit()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "AppQuit");
		}

		public static void AppAbort()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "AppAbort");
		}

		public static void ResetConnectionFailureCount()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "ResetConnectionFailureCount");
		}

		public static void ConcedeIfReconnectDisabled()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "ConcedeIfReconnectDisabled");
		}

		public static UnavailableReason GetHearthstoneUnavailable(bool gamePacket)
		{
			return MonoClass.smethod_15<UnavailableReason>(TritonHs.MainAssemblyPath, "", "Network", "GetHearthstoneUnavailable", new object[1] { gamePacket });
		}

		public static void BuyCard(int assetId, TAG_PREMIUM premium, int count, int unitBuyPrice, int currentCollectionCount)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "BuyCard", assetId, premium, count, unitBuyPrice, currentCollectionCount);
		}

		public static void SellCard(int assetId, TAG_PREMIUM premium, int count, int unitSellPrice, int currentCollectionCount)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SellCard", assetId, premium, count, unitSellPrice, currentCollectionCount);
		}

		public static void CloseCardMarket()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "CloseCardMarket");
		}

		public static void GetAllClientOptions()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "GetAllClientOptions");
		}

		public static BnetLoginState BattleNetStatus()
		{
			return MonoClass.smethod_14<BnetLoginState>(TritonHs.MainAssemblyPath, "", "Network", "BattleNetStatus", Array.Empty<object>());
		}

		public static bool IsLoggedIn()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "IsLoggedIn", Array.Empty<object>());
		}

		public static bool ShouldBeConnectedToAurora()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "ShouldBeConnectedToAurora", Array.Empty<object>());
		}

		public static void SetShouldBeConnectedToAurora(bool shouldBeConnected)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SetShouldBeConnectedToAurora", shouldBeConnected);
		}

		public static void AcceptFriendInvite(BnetInvitationId inviteid)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AcceptFriendInvite", inviteid);
		}

		public static void RevokeFriendInvite(BnetInvitationId inviteid)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "RevokeFriendInvite", inviteid);
		}

		public static void DeclineFriendInvite(BnetInvitationId inviteid)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "DeclineFriendInvite", inviteid);
		}

		public static void IgnoreFriendInvite(BnetInvitationId inviteid)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "IgnoreFriendInvite", inviteid);
		}

		public static void SendFriendInvite(string sender, string target, bool byEmail)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SendFriendInvite", sender, target, byEmail);
		}

		public static void SendFriendInviteByEmail(string sender, string target)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SendFriendInviteByEmail", sender, target);
		}

		public static void SendFriendInviteByBattleTag(string sender, string target)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SendFriendInviteByBattleTag", sender, target);
		}

		public static Network Get()
		{
			return MonoClass.smethod_15<Network>(TritonHs.MainAssemblyPath, "", "Network", "Get", Array.Empty<object>());
		}

		public static string GetUsername()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetUsername");
		}

		public static string GetTargetServer()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetTargetServer");
		}

		public static int GetPort()
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "Network", "GetPort", Array.Empty<object>());
		}

		public static bool IsVersionInt()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "IsVersionInt", Array.Empty<object>());
		}

		public static bool GetIsVersionIntFromConfig()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "GetIsVersionIntFromConfig", Array.Empty<object>());
		}

		public static string GetVersion()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetVersion");
		}

		public static string GetVersionFromConfig()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetVersionFromConfig");
		}

		public static void DoLoginUpdate()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "DoLoginUpdate");
		}

		public static void OnStartupPacketSequenceComplete()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "OnStartupPacketSequenceComplete");
		}

		public static bool RequiresScenarioIdAttribute(GameType gameType)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "RequiresScenarioIdAttribute", new object[1] { gameType });
		}

		public static GameCancelInfo GetGameCancelInfo()
		{
			return MonoClass.smethod_15<GameCancelInfo>(TritonHs.MainAssemblyPath, "", "Network", "GetGameCancelInfo", Array.Empty<object>());
		}

		public static TurnTimerInfo GetTurnTimerInfo()
		{
			return MonoClass.smethod_15<TurnTimerInfo>(TritonHs.MainAssemblyPath, "", "Network", "GetTurnTimerInfo", Array.Empty<object>());
		}

		public static int GetNAckOption()
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "Network", "GetNAckOption", Array.Empty<object>());
		}

		public static void DisconnectFromGameServer()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "DisconnectFromGameServer");
		}

		public static bool WasDisconnectRequested()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "WasDisconnectRequested", Array.Empty<object>());
		}

		public static bool IsConnectedToGameServer()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "IsConnectedToGameServer", Array.Empty<object>());
		}

		public static bool GameServerHasEvents()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "GameServerHasEvents", Array.Empty<object>());
		}

		public static bool WasGameConceded()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "WasGameConceded", Array.Empty<object>());
		}

		public static void Concede()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "Concede");
		}

		public static void AutoConcede()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "AutoConcede");
		}

		public static EntityChoices GetEntityChoices()
		{
			return MonoClass.smethod_15<EntityChoices>(TritonHs.MainAssemblyPath, "", "Network", "GetEntityChoices", Array.Empty<object>());
		}

		public static EntitiesChosen GetEntitiesChosen()
		{
			return MonoClass.smethod_15<EntitiesChosen>(TritonHs.MainAssemblyPath, "", "Network", "GetEntitiesChosen", Array.Empty<object>());
		}

		public static Options GetOptions()
		{
			return MonoClass.smethod_15<Options>(TritonHs.MainAssemblyPath, "", "Network", "GetOptions", Array.Empty<object>());
		}

		public static UserUI GetUserUI()
		{
			return MonoClass.smethod_15<UserUI>(TritonHs.MainAssemblyPath, "", "Network", "GetUserUI", Array.Empty<object>());
		}

		public static GameSetup GetGameSetupInfo()
		{
			return MonoClass.smethod_15<GameSetup>(TritonHs.MainAssemblyPath, "", "Network", "GetGameSetupInfo", Array.Empty<object>());
		}

		public static List<PowerHistory> GetPowerHistory()
		{
			return MonoClass.smethod_15<Class271<PowerHistory>>(TritonHs.MainAssemblyPath, "", "Network", "GetPowerHistory", Array.Empty<object>())?.method_25();
		}

		public static List<int> MakeChoicesList(int choice1, int choice2, int choice3)
		{
			return MonoClass.smethod_15<Class270<int>>(TritonHs.MainAssemblyPath, "", "Network", "MakeChoicesList", new object[3] { choice1, choice2, choice3 })?.method_25();
		}

		public static void ValidateAchieve(int achieveID)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "ValidateAchieve", achieveID);
		}

		public static void RequestCancelQuest(int achieveID)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "RequestCancelQuest", achieveID);
		}

		public static CanceledQuest GetCanceledQuest()
		{
			return MonoClass.smethod_15<CanceledQuest>(TritonHs.MainAssemblyPath, "", "Network", "GetCanceledQuest", Array.Empty<object>());
		}

		public static TriggeredEvent GetTriggerEventResponse()
		{
			return MonoClass.smethod_15<TriggeredEvent>(TritonHs.MainAssemblyPath, "", "Network", "GetTriggerEventResponse", Array.Empty<object>());
		}

		public static void RequestAdventureProgress()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestAdventureProgress");
		}

		public static List<AdventureProgress> GetAdventureProgressResponse()
		{
			return MonoClass.smethod_15<Class271<AdventureProgress>>(TritonHs.MainAssemblyPath, "", "Network", "GetAdventureProgressResponse", Array.Empty<object>())?.method_25();
		}

		public static BeginDraft GetBeginDraft()
		{
			return MonoClass.smethod_15<BeginDraft>(TritonHs.MainAssemblyPath, "", "Network", "GetBeginDraft", Array.Empty<object>());
		}

		public static DraftChoicesAndContents GetDraftChoicesAndContents()
		{
			return MonoClass.smethod_15<DraftChoicesAndContents>(TritonHs.MainAssemblyPath, "", "Network", "GetDraftChoicesAndContents", Array.Empty<object>());
		}

		public static DraftChosen GetDraftChosen()
		{
			return MonoClass.smethod_15<DraftChosen>(TritonHs.MainAssemblyPath, "", "Network", "GetDraftChosen", Array.Empty<object>());
		}

		public static void MakeDraftChoice(long deckID, int slot, int index, int premium)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "MakeDraftChoice", deckID, slot, index, premium);
		}

		public static void RequestDraftChoicesAndContents()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestDraftChoicesAndContents");
		}

		public static void SendArenaSessionRequest()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "SendArenaSessionRequest");
		}

		public static void DraftBegin()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "DraftBegin");
		}

		public static void DraftRetire(long deckID, int slot, int seasonId)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "DraftRetire", deckID, slot, seasonId);
		}

		public static DraftRetired GetRetiredDraft()
		{
			return MonoClass.smethod_15<DraftRetired>(TritonHs.MainAssemblyPath, "", "Network", "GetRetiredDraft", Array.Empty<object>());
		}

		public static void AckDraftRewards(long deckID, int slot)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AckDraftRewards", deckID, slot);
		}

		public static long GetRewardsAckDraftID()
		{
			return MonoClass.smethod_14<long>(TritonHs.MainAssemblyPath, "", "Network", "GetRewardsAckDraftID", Array.Empty<object>());
		}

		public static void DraftRequestDisableGoldens()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "DraftRequestDisableGoldens");
		}

		public static DraftChoicesAndContents GetDraftRemoveGoldensResponse()
		{
			return MonoClass.smethod_15<DraftChoicesAndContents>(TritonHs.MainAssemblyPath, "", "Network", "GetDraftRemoveGoldensResponse", Array.Empty<object>());
		}

		public static void MassDisenchant()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "MassDisenchant");
		}

		public static MassDisenchantResponse GetMassDisenchantResponse()
		{
			return MonoClass.smethod_15<MassDisenchantResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetMassDisenchantResponse", Array.Empty<object>());
		}

		public static void SetFavoriteHero(TAG_CLASS heroClass, NetCache.CardDefinition hero)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SetFavoriteHero", heroClass, hero);
		}

		public static SetFavoriteHeroResponse GetSetFavoriteHeroResponse()
		{
			return MonoClass.smethod_15<SetFavoriteHeroResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetSetFavoriteHeroResponse", Array.Empty<object>());
		}

		public static void RequestRecruitAFriendUrl()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestRecruitAFriendUrl");
		}

		public static void RequestRecruitAFriendData()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestRecruitAFriendData");
		}

		public static void RequestProcessRecruitAFriend()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestProcessRecruitAFriend");
		}

		public static PurchaseCanceledResponse GetPurchaseCanceledResponse()
		{
			return MonoClass.smethod_15<PurchaseCanceledResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetPurchaseCanceledResponse", Array.Empty<object>());
		}

		public static BattlePayStatus GetBattlePayStatusResponse()
		{
			return MonoClass.smethod_15<BattlePayStatus>(TritonHs.MainAssemblyPath, "", "Network", "GetBattlePayStatusResponse", Array.Empty<object>());
		}

		public static BattlePayConfig GetBattlePayConfigResponse()
		{
			return MonoClass.smethod_15<BattlePayConfig>(TritonHs.MainAssemblyPath, "", "Network", "GetBattlePayConfigResponse", Array.Empty<object>());
		}

		public static void GetPurchaseMethod(string productID, int quantity, Currency currency)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "GetPurchaseMethod", productID, quantity, currency);
		}

		public static void ConfirmPurchase()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "ConfirmPurchase");
		}

		public static void GetThirdPartyPurchaseStatus(string transactionId)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "GetThirdPartyPurchaseStatus", transactionId);
		}

		public static PurchaseMethod GetPurchaseMethodResponse()
		{
			return MonoClass.smethod_15<PurchaseMethod>(TritonHs.MainAssemblyPath, "", "Network", "GetPurchaseMethodResponse", Array.Empty<object>());
		}

		public static PurchaseResponse GetPurchaseResponse()
		{
			return MonoClass.smethod_15<PurchaseResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetPurchaseResponse", Array.Empty<object>());
		}

		public static PurchaseViaGoldResponse GetPurchaseWithGoldResponse()
		{
			return MonoClass.smethod_15<PurchaseViaGoldResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetPurchaseWithGoldResponse", Array.Empty<object>());
		}

		public static ThirdPartyPurchaseStatusResponse GetThirdPartyPurchaseStatusResponse()
		{
			return MonoClass.smethod_15<ThirdPartyPurchaseStatusResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetThirdPartyPurchaseStatusResponse", Array.Empty<object>());
		}

		public static CardBackResponse GetCardBackResponse()
		{
			return MonoClass.smethod_15<CardBackResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetCardBackResponse", Array.Empty<object>());
		}

		public static void SetDefaultCardBack(int cardBack)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SetDefaultCardBack", cardBack);
		}

		public static NetCache.NetCacheCardBacks GetCardBacks()
		{
			return MonoClass.smethod_15<NetCache.NetCacheCardBacks>(TritonHs.MainAssemblyPath, "", "Network", "GetCardBacks", Array.Empty<object>());
		}

		public static void OpenBooster(int id)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "OpenBooster", id);
		}

		public static List<NetCache.BoosterCard> OpenedBooster()
		{
			return MonoClass.smethod_15<Class271<NetCache.BoosterCard>>(TritonHs.MainAssemblyPath, "", "Network", "OpenedBooster", Array.Empty<object>())?.method_25();
		}

		public static DBAction GetDeckResponse()
		{
			return MonoClass.smethod_15<DBAction>(TritonHs.MainAssemblyPath, "", "Network", "GetDeckResponse", Array.Empty<object>());
		}

		public static DBAction GetDbAction()
		{
			return MonoClass.smethod_15<DBAction>(TritonHs.MainAssemblyPath, "", "Network", "GetDbAction", Array.Empty<object>());
		}

		public static NetCache.NetCacheDecks GetDeckHeaders()
		{
			return MonoClass.smethod_15<NetCache.NetCacheDecks>(TritonHs.MainAssemblyPath, "", "Network", "GetDeckHeaders", Array.Empty<object>());
		}

		public static bool DeckNeedsName(ulong deckValidityFlags)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "DeckNeedsName", new object[1] { deckValidityFlags });
		}

		public static bool AreDeckFlagsWild(ulong deckValidityFlags)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "AreDeckFlagsWild", new object[1] { deckValidityFlags });
		}

		public static bool AreDeckFlagsLocked(ulong deckValidityFlags)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "AreDeckFlagsLocked", new object[1] { deckValidityFlags });
		}

		public static NetCache.DeckHeader GetCreatedDeck()
		{
			return MonoClass.smethod_15<NetCache.DeckHeader>(TritonHs.MainAssemblyPath, "", "Network", "GetCreatedDeck", Array.Empty<object>());
		}

		public static int GetDeckLimit()
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "Network", "GetDeckLimit", Array.Empty<object>());
		}

		public static long GetDeletedDeckID()
		{
			return MonoClass.smethod_14<long>(TritonHs.MainAssemblyPath, "", "Network", "GetDeletedDeckID", Array.Empty<object>());
		}

		public static DeckName GetRenamedDeck()
		{
			return MonoClass.smethod_15<DeckName>(TritonHs.MainAssemblyPath, "", "Network", "GetRenamedDeck", Array.Empty<object>());
		}

		public static GenericResponse GetGenericResponse()
		{
			return MonoClass.smethod_15<GenericResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetGenericResponse", Array.Empty<object>());
		}

		public static NetCache.NetCacheProfileProgress GetProfileProgress()
		{
			return MonoClass.smethod_15<NetCache.NetCacheProfileProgress>(TritonHs.MainAssemblyPath, "", "Network", "GetProfileProgress", Array.Empty<object>());
		}

		public static void SetProgress(long value)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SetProgress", value);
		}

		public static NetCache.NetCachePlayQueue GetPlayQueue()
		{
			return MonoClass.smethod_15<NetCache.NetCachePlayQueue>(TritonHs.MainAssemblyPath, "", "Network", "GetPlayQueue", Array.Empty<object>());
		}

		public static NetCache.NetCacheMedalInfo GetMedalInfo()
		{
			return MonoClass.smethod_15<NetCache.NetCacheMedalInfo>(TritonHs.MainAssemblyPath, "", "Network", "GetMedalInfo", Array.Empty<object>());
		}

		public static NetCache.NetCacheRewardProgress GetRewardProgress()
		{
			return MonoClass.smethod_15<NetCache.NetCacheRewardProgress>(TritonHs.MainAssemblyPath, "", "Network", "GetRewardProgress", Array.Empty<object>());
		}

		public static NetCache.NetCacheGamesPlayed GetGamesInfo()
		{
			return MonoClass.smethod_15<NetCache.NetCacheGamesPlayed>(TritonHs.MainAssemblyPath, "", "Network", "GetGamesInfo", Array.Empty<object>());
		}

		public static void RequestTavernBrawlInfo(BrawlType brawlType)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "RequestTavernBrawlInfo", brawlType);
		}

		public static void RequestTavernBrawlPlayerRecord(BrawlType brawlType)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "RequestTavernBrawlPlayerRecord", brawlType);
		}

		public static void TavernBrawlRetire()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "TavernBrawlRetire");
		}

		public static void RequestTavernBrawlSessionBegin()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestTavernBrawlSessionBegin");
		}

		public static void AckTavernBrawlSessionRewards()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "AckTavernBrawlSessionRewards");
		}

		public static void RequestAccountLicensesUpdate()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestAccountLicensesUpdate");
		}

		public static void AckNotice(long id)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AckNotice", id);
		}

		public static void AckAchieveProgress(int id, int ackProgress)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AckAchieveProgress", id, ackProgress);
		}

		public static void CheckAccountLicenseAchieve(int achieveID)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "CheckAccountLicenseAchieve", achieveID);
		}

		public static AccountLicenseAchieveResponse GetAccountLicenseAchieveResponse()
		{
			return MonoClass.smethod_15<AccountLicenseAchieveResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetAccountLicenseAchieveResponse", Array.Empty<object>());
		}

		public static void AckCardSeenBefore(int assetId, TAG_PREMIUM premium)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AckCardSeenBefore", assetId, premium);
		}

		public static void AckWingProgress(int wingId, int ackId)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AckWingProgress", wingId, ackId);
		}

		public static void AcknowledgeBanner(int banner)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "AcknowledgeBanner", banner);
		}

		public static void SendAckCardsSeen()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "SendAckCardsSeen");
		}

		public static void CheckOutOfFSG(long gatheringID)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "CheckOutOfFSG", gatheringID);
		}

		public static void RequestReturningPlayerOptOut()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestReturningPlayerOptOut");
		}

		public static CardSaleResult GetCardSaleResult()
		{
			return MonoClass.smethod_15<CardSaleResult>(TritonHs.MainAssemblyPath, "", "Network", "GetCardSaleResult", Array.Empty<object>());
		}

		public static void RequestAssetsVersion()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "RequestAssetsVersion");
		}

		public static void LoginOk()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "LoginOk");
		}

		public static bool SendDebugConsoleCommand(string command)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "Network", "SendDebugConsoleCommand", new object[1] { command });
		}

		public static void SendDebugConsoleResponse(int responseType, string message)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "Network", "SendDebugConsoleResponse", responseType, message);
		}

		public static string GetDebugConsoleCommand()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetDebugConsoleCommand");
		}

		public static DebugConsoleResponse GetDebugConsoleResponse()
		{
			return MonoClass.smethod_15<DebugConsoleResponse>(TritonHs.MainAssemblyPath, "", "Network", "GetDebugConsoleResponse", Array.Empty<object>());
		}

		public static void SendLocateCheatServerRequest()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "SendLocateCheatServerRequest");
		}

		public static void SimulateUncleanDisconnectFromGameServer()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "Network", "SimulateUncleanDisconnectFromGameServer");
		}

		public static string GetStoredUserName()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetStoredUserName");
		}

		public static string GetStoredBNetIP()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetStoredBNetIP");
		}

		public static string GetStoredVersion()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "Network", "GetStoredVersion");
		}

		public bool FakeHandleType(MonoEnum enumId)
		{
			return method_10<bool>("FakeHandleType", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { enumId });
		}

		public bool FakeHandleType(int id)
		{
			return method_10<bool>("FakeHandleType", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { id });
		}

		public bool HandleType(int id)
		{
			return method_11<bool>("HandleType", new object[1] { id });
		}

		public bool CanIgnoreUnhandledPacket(int id)
		{
			return method_11<bool>("CanIgnoreUnhandledPacket", new object[1] { id });
		}

		public bool ProcessGameQueue()
		{
			return method_11<bool>("ProcessGameQueue", Array.Empty<object>());
		}

		public bool ProcessGameServer()
		{
			return method_11<bool>("ProcessGameServer", Array.Empty<object>());
		}

		public bool ProcessUtilServer()
		{
			return method_11<bool>("ProcessUtilServer", Array.Empty<object>());
		}

		public bool ProcessConsole()
		{
			return method_11<bool>("ProcessConsole", Array.Empty<object>());
		}

		public bool HaveUnhandledPackets()
		{
			return method_11<bool>("HaveUnhandledPackets", Array.Empty<object>());
		}

		public void ProcessNetwork()
		{
			method_8("ProcessNetwork");
		}

		public void ProcessQueuePosition()
		{
			method_8("ProcessQueuePosition");
		}

		public void ProcessAurora()
		{
			method_8("ProcessAurora");
		}

		public void ProcessBnetEvents()
		{
			method_8("ProcessBnetEvents");
		}

		public void ProcessWhispers()
		{
			method_8("ProcessWhispers");
		}

		public void ProcessParties()
		{
			method_8("ProcessParties");
		}

		public void ProcessBroadcasts()
		{
			method_8("ProcessBroadcasts");
		}

		public void ProcessNotifications()
		{
			method_8("ProcessNotifications");
		}

		public void ProcessFriends()
		{
			method_8("ProcessFriends");
		}

		public void ProcessPresence()
		{
			method_8("ProcessPresence");
		}

		public void ProcessChallenges()
		{
			method_8("ProcessChallenges");
		}

		public void ProcessErrors()
		{
			method_8("ProcessErrors");
		}

		public void ShowConnectionFailureError(string error)
		{
			method_8("ShowConnectionFailureError", error);
		}

		public void ShowBreakingNewsOrError(string error, float timeBeforeAllowReset)
		{
			method_8("ShowBreakingNewsOrError", error, timeBeforeAllowReset);
		}

		public bool ProcessDelayedError()
		{
			return method_11<bool>("ProcessDelayedError", Array.Empty<object>());
		}

		public float DelayForConnectionFailures(int numFailures)
		{
			return method_11<float>("DelayForConnectionFailures", new object[1] { numFailures });
		}

		public void EnsureSubscribedTo(UtilSystemId systemChannel)
		{
			method_8("EnsureSubscribedTo", systemChannel);
		}

		public void AnswerChallenge(ulong challengeID, string answer)
		{
			method_8("AnswerChallenge", challengeID, answer);
		}

		public void CancelChallenge(ulong challengeID)
		{
			method_8("CancelChallenge", challengeID);
		}

		public bool RetryGotoGameServer()
		{
			return method_11<bool>("RetryGotoGameServer", Array.Empty<object>());
		}

		public void ClearLastGameServerJoined()
		{
			method_8("ClearLastGameServerJoined");
		}

		public void OnLoginStarted()
		{
			method_8("OnLoginStarted");
		}

		public bool IsFindingGame()
		{
			return method_11<bool>("IsFindingGame", Array.Empty<object>());
		}

		public void CancelFindGame()
		{
			method_8("CancelFindGame");
		}

		public void GoToNoAccountTutorialServer(int scenario)
		{
			method_8("GoToNoAccountTutorialServer", scenario);
		}

		public void ThrowDnsResolveError(string environment)
		{
			method_8("ThrowDnsResolveError", environment);
		}

		public void GetGameState()
		{
			method_8("GetGameState");
		}

		public void SendOption(int id, int index, int target, int sub, int pos)
		{
			method_8("SendOption", id, index, target, sub, pos);
		}

		public void SendUserUI(int overCard, int heldCard, int arrowOrigin, int x, int y)
		{
			method_8("SendUserUI", overCard, heldCard, arrowOrigin, x, y);
		}

		public void SendEmote(EmoteType emote)
		{
			method_8("SendEmote", emote);
		}

		public void SendRemoveAllSpectators(bool regenerateSpectatorPassword)
		{
			method_8("SendRemoveAllSpectators", regenerateSpectatorPassword);
		}

		public void RenameDeck(long deck, string name)
		{
			method_8("RenameDeck", deck, name);
		}

		public void DeleteDeck(long deck)
		{
			method_8("DeleteDeck", deck);
		}

		public void SetDeckTemplateSource(long deck, int templateID)
		{
			method_8("SetDeckTemplateSource", deck, templateID);
		}
	}
}
